package org.ipower.platform.utils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/**
 *  数据集合基础类。
 * @author young
 */
public abstract class BaseCollection<T> implements Collection<T>, Comparator<T>, Serializable{
    private List<T> items;
    /**
     * 构造函数。
     * */
    public BaseCollection(){
        this.items = new ArrayList<T>();
    }
    /**
     * 根据索引加载数据。
     * @param index 索引下标。
     * @return 返回索引下的对象。
     * */
    public T get(int index){
        if(index > -1 && index < this.size()){
            return this.items.get(index);
        }
        return null;
    }
    /**
     * 获取数据集合。
     * @return 数据集合。
     * */
    protected List<T> getItems(){
        return this.items;
    }
    /**
     * 获取集合对象数量。
     * @return 集合对象数。
     * */
    @Override
    public int size() {
         return this.items.size();
    }
    /**
     * 集合是否为空。
     * @return 为空则为True。
     * */
    @Override
    public boolean isEmpty() {
       return this.items.isEmpty();
    }
    /**
     * 是否包含对象。
     * @return 包含则为true.
     * */
    @Override
    public boolean contains(Object o) {
         if(o != null){
             return this.items.contains(o);
         }
         return false;
    }
    /**
     * 迭代循环。
     * @return 迭代对象。
     * */
    @Override
    public Iterator<T> iterator() {
        return this.items.iterator();
    }
    /**
     * 转换为数组。
     * @return 数组对象。
     * */
    @Override
    public Object[] toArray() {
         return this.items.toArray();
    }
    /**
     * 转换为数组对象。
     * @return 数组对象。
     * */
    @Override
    public <T> T[] toArray(T[] a) {
        return this.items.toArray(a);
    }
    /**
     * 添加对象。
     * @param e 泛型对象。
     * @return 添加成功为true,否则为false.
     * */
    @Override
    public boolean add(T e) {
        if(e != null){
           return this.items.add(e);
        }
        return false;
    }
    /**
     * 移除对象。
     * @param o 移除对象。
     * @return 移除成功为true,否则为false.
     * */
    @Override
    public boolean remove(Object o) {
        if(o != null){
            return this.items.remove(o);
        }
        return false;
    }
    /**
     * 是否包含集合。
     * @param c 集合。
     * @return 包含返回true,否则返回false.
     * */
    @Override
    public boolean containsAll(Collection<?> c) {
         if(c != null){
             return this.items.containsAll(c);
         }
         return false;
    }
    /**
     * 将集合全部添加。
     * @param c 集合。
     * @return 全部添加返回true,否则返回false.
     * */
    @Override
    public boolean addAll(Collection<? extends T> c) {
        if(c != null){
            return this.items.addAll(c);
        }
        return false;
    }
    /**
     * 移除集合中的全部对象。
     * @param c 集合。
     * @return 移除返回true,否则返回false.
     * */
    @Override
    public boolean removeAll(Collection<?> c) {
        if(c != null){
            return this.items.removeAll(c);
        }
        return false;
    }
    /**
     * 保留集合中的全部对象。
     * @param c 集合。
     * @return 保留则返回true,否则返回false.
     * */
    @Override
    public boolean retainAll(Collection<?> c) {
         if(c != null){
             return this.items.retainAll(c);
         }
         return false;
    }
    /**
     * 清除数据。
     * */
    @Override
    public void clear() {
        this.items.clear();
    }
    /**
     * 对比排序。
     * @param o1 集合内对象。
     * @param o2 集合内对象。
     * @return 对比结果。
     * */
    @Override
    public abstract int compare(T o1, T o2);
}